use tauri::{AppHandle, Manager};

use crate::storage;

/// 清理所有聊天记录
/// 只删除聊天记录文件（通过检查文件内容结构，确保不会误删其他数据）
#[tauri::command]
pub async fn clear_all_chat_messages(
    app: AppHandle,
) -> Result<(), String> {
    let data_dir = app
        .path()
        .app_data_dir()
        .map_err(|e| format!("获取应用数据目录失败: {}", e))?;
    
    // 查找所有聊天记录文件
    if let Ok(entries) = std::fs::read_dir(&data_dir) {
        for entry in entries {
            if let Ok(entry) = entry {
                let path = entry.path();
                if path.is_file() {
                    // 读取文件内容，检查是否是聊天记录
                    if let Ok(content) = tokio::fs::read_to_string(&path).await {
                        if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
                            // 检查是否是聊天记录数组
                            // 聊天记录数组的特征：数组中的对象包含 message_id, from_user_id, to_user_id, message 等字段
                            // 严格排除好友列表（好友列表包含 owner_id, to_id，但不包含 message_id 或 message）
                            if json.is_array() {
                                let array = json.as_array().unwrap();
                                
                                // 如果数组为空，跳过（可能是空的聊天记录或空的好友列表，不删除）
                                if array.is_empty() {
                                    continue;
                                }
                                
                                // 检查是否是好友列表（优先判断，避免误删）
                                let is_friends_list = array.iter().any(|item| {
                                    if let Some(obj) = item.as_object() {
                                        // 好友列表的特征：
                                        // 1. 包含 owner_id 和 to_id
                                        // 2. 不包含 message_id 和 message
                                        // 3. 可能包含 remark, user 等字段
                                        obj.contains_key("owner_id") && 
                                        obj.contains_key("to_id") && 
                                        !obj.contains_key("message_id") && 
                                        !obj.contains_key("message")
                                    } else {
                                        false
                                    }
                                });
                                
                                // 如果是好友列表，跳过，不删除
                                if is_friends_list {
                                    eprintln!("跳过好友列表文件: {}", path.display());
                                    continue;
                                }
                                
                                // 检查是否是聊天记录
                                let is_chat_messages = array.iter().any(|item| {
                                    if let Some(obj) = item.as_object() {
                                        // 聊天记录的特征：
                                        // 1. 包含 message_id，或者
                                        // 2. 同时包含 from_user_id, to_user_id, message
                                        obj.contains_key("message_id") || 
                                        (obj.contains_key("from_user_id") && 
                                         obj.contains_key("to_user_id") && 
                                         obj.contains_key("message"))
                                    } else {
                                        false
                                    }
                                });
                                
                                // 只删除确认是聊天记录的文件
                                if is_chat_messages {
                                    if let Err(e) = tokio::fs::remove_file(&path).await {
                                        eprintln!("删除聊天记录文件失败: {} - {}", path.display(), e);
                                    } else {
                                        eprintln!("已删除聊天记录文件: {}", path.display());
                                    }
                                } else {
                                    eprintln!("跳过非聊天记录文件: {}", path.display());
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    Ok(())
}

/// 清理特定用户的聊天记录
#[tauri::command]
pub async fn clear_user_chat_messages(
    user_id: String,
    app: AppHandle,
) -> Result<(), String> {
    let key = format!("chat_messages_{}", user_id);
    storage::secure_store_remove(key, app).await
}

/// 清理特定群组的本地聊天记录
/// 从当前用户的消息存储中删除所有与该群组相关的消息
#[tauri::command]
pub async fn clear_group_chat_messages(
    group_id: String,
    app: AppHandle,
) -> Result<u32, String> {
    use serde_json::Value;
    
    // 首先需要获取当前用户的ID
    // 尝试从存储中读取 openId、snowflakeId 或 userId（按优先级）
    let mut current_user_id = storage::secure_store_get("openId".to_string(), app.clone())
        .await
        .ok()
        .flatten();
    
    // 如果 openId 不存在，尝试读取 snowflakeId
    if current_user_id.is_none() {
        current_user_id = storage::secure_store_get("snowflakeId".to_string(), app.clone())
            .await
            .ok()
            .flatten();
    }
    
    // 如果 snowflakeId 也不存在，尝试读取 userId
    if current_user_id.is_none() {
        current_user_id = storage::secure_store_get("userId".to_string(), app.clone())
            .await
            .ok()
            .flatten();
    }
    
    let current_user_id = current_user_id.ok_or_else(|| "无法获取当前用户ID，请先登录".to_string())?;
    
    // 构建存储键名
    let storage_key = format!("chat_messages_{}", current_user_id);
    
    // 读取当前用户的消息列表
    let messages_json = storage::secure_store_get(storage_key.clone(), app.clone())
        .await
        .map_err(|e| format!("读取消息存储失败: {}", e))?
        .unwrap_or_else(|| "[]".to_string());
    
    // 解析 JSON
    let mut messages: Vec<Value> = serde_json::from_str(&messages_json)
        .map_err(|e| format!("解析消息JSON失败: {}", e))?;
    
    // 记录删除前的消息数量
    let before_count = messages.len();
    eprintln!("开始清理群组消息 - 群组ID: {}, 当前消息总数: {}", group_id, before_count);
    
    // 移除可能的 group_ 前缀，用于比较
    let target_group_id = group_id.replace("group_", "").trim().to_string();
    eprintln!("目标群组ID（标准化后）: '{}'", target_group_id);
    
    // 统计信息
    let mut matched_messages = 0;
    let mut unmatched_messages = 0;
    let mut no_chat_type_messages = 0;
    
    // 过滤掉所有与该群组相关的消息
    // 群组消息的特征：chat_type === 2 且 to_user_id === group_id
    messages.retain(|msg| {
        if let Some(obj) = msg.as_object() {
            // 获取 to_user_id（用于匹配）
            let to_user_id = obj
                .get("to_user_id")
                .and_then(|v| v.as_str())
                .unwrap_or("");
            
            // 获取 chat_type
            let chat_type = obj
                .get("chat_type")
                .and_then(|v| v.as_u64())
                .or_else(|| {
                    // 尝试作为 i64 读取
                    obj.get("chat_type")
                        .and_then(|v| v.as_i64())
                        .map(|v| v as u64)
                });
            
            // 检查是否是群组消息
            let is_group_message = chat_type.map(|v| v == 2).unwrap_or(false);
            
            if is_group_message {
                // 这是群组消息，检查 to_user_id 是否匹配群组ID
                let msg_group_id = to_user_id.replace("group_", "").trim().to_string();
                
                // 比较（忽略大小写，但通常ID是大小写敏感的）
                let matches = msg_group_id == target_group_id;
                
                if matches {
                    matched_messages += 1;
                    eprintln!("匹配到群组消息 - to_user_id: '{}', 标准化后: '{}', message_id: {}", 
                        to_user_id, 
                        msg_group_id,
                        obj.get("message_id").and_then(|v| v.as_str()).unwrap_or("unknown")
                    );
                    // 匹配，删除这条消息
                    false
                } else {
                    unmatched_messages += 1;
                    // 不匹配，保留这条消息
                    true
                }
            } else {
                // 没有 chat_type 或 chat_type 不是 2
                // 对于旧消息，可能需要通过其他方式判断
                // 但为了安全，我们只删除明确标记为群组消息且匹配的消息
                if chat_type.is_none() {
                    no_chat_type_messages += 1;
                }
                // 不是群组消息，保留
                true
            }
        } else {
            // 不是对象，保留（可能是旧格式）
            true
        }
    });
    
    // 记录删除后的消息数量
    let after_count = messages.len();
    let deleted_count = before_count - after_count;
    
    eprintln!("清理完成 - 匹配消息: {}, 不匹配群组消息: {}, 无chat_type消息: {}, 删除: {}, 剩余: {}", 
        matched_messages, 
        unmatched_messages, 
        no_chat_type_messages,
        deleted_count, 
        after_count
    );
    
    // 保存更新后的消息列表
    let updated_json = serde_json::to_string(&messages)
        .map_err(|e| format!("序列化消息JSON失败: {}", e))?;
    
    storage::secure_store_set(storage_key, updated_json, app)
        .await
        .map_err(|e| format!("保存消息存储失败: {}", e))?;
    
    eprintln!("已清空群组 {} 的本地消息，删除了 {} 条消息", group_id, deleted_count);
    
    Ok(deleted_count as u32)
}

